/**
 * WordPress Spider Monitor - 客户端安全验证模块
 * 
 * 此模块提供客户端付费功能验证，与服务器端安全模块配合使用
 * 防止客户端绕过授权检查
 */

(function($) {
    'use strict';
    
    // 安全验证模块
    window.WP_Spider_Premium_Security = {
        
        // 配置
        config: {
            tokenExpiry: 300000, // 5分钟令牌过期时间
            maxRetries: 3,
            retryDelay: 1000
        },
        
        // 缓存
        cache: {
            tokens: {},
            permissions: {}
        },
        
        /**
         * 验证选择器权限
         * @param {jQuery} $selector 选择器元素
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @returns {boolean} 是否通过验证
         */
        validateSelector: function($selector, feature, period) {
            try {
                // 检查是否为付费选项
                const $selectedOption = $selector.find('option:selected');
                if (!$selectedOption.hasClass('premium-option') || !$selectedOption.data('premium')) {
                    return true; // 非付费选项，直接通过
                }
                
                // 简化验证：直接检查全局激活状态
                if (window.wpSpiderMonitor && window.wpSpiderMonitor.subscription && window.wpSpiderMonitor.subscription.is_premium) {
                    return true; // 已激活，直接通过
                }
                
                // 如果全局状态不可用，尝试从服务器验证
                const isValid = this.validateServerPermission(feature, period);
                
                if (!isValid) {
                    this.showPremiumNotice(feature, period);
                    this.resetToFreeOption($selector);
                }
                
                return isValid;
                
            } catch (error) {
                console.error('[SpiderMonitor] Selector validation error:', error);
                return false;
            }
        },
        
        /**
         * 验证服务器端权限
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @returns {boolean} 是否通过验证
         */
        validateServerPermission: function(feature, period) {
            try {
                // 检查是否有有效的访问令牌
                const token = this.getValidToken(feature, period);
                if (!token) {
                    return false;
                }
                
                // 验证令牌
                return this.verifyToken(token, feature, period);
                
            } catch (error) {
                console.error('[SpiderMonitor] Server permission validation error:', error);
                return false;
            }
        },
        
        /**
         * 获取有效令牌
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @returns {string|null} 访问令牌
         */
        getValidToken: function(feature, period) {
            const cacheKey = `${feature}_${period}`;
            const cached = this.cache.tokens[cacheKey];
            
            // 检查缓存令牌是否有效
            if (cached && this.isTokenValid(cached)) {
                return cached.token;
            }
            
            // 请求新令牌
            return this.requestNewToken(feature, period);
        },
        
        /**
         * 请求新令牌
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @returns {string|null} 访问令牌
         */
        requestNewToken: function(feature, period) {
            try {
                const response = this.syncAjaxRequest({
                    action: 'wp_spider_validate_premium_access',
                    feature: feature,
                    period: period,
                    nonce: wpSpiderMonitor.nonce
                });
                
                if (response && response.success && response.data.access_token) {
                    const token = response.data.access_token;
                    const fingerprint = response.data.fingerprint;
                    
                    // 缓存令牌
                    this.cache.tokens[`${feature}_${period}`] = {
                        token: token,
                        fingerprint: fingerprint,
                        timestamp: Date.now()
                    };
                    
                    return token;
                }
                
                return null;
                
            } catch (error) {
                console.error('[SpiderMonitor] Token request error:', error);
                return null;
            }
        },
        
        /**
         * 验证令牌
         * @param {string} token 访问令牌
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @returns {boolean} 令牌是否有效
         */
        verifyToken: function(token, feature, period) {
            try {
                // 生成客户端验证哈希
                const clientHash = this.generateClientHash(feature, period, token);
                
                // 发送验证请求
                const response = this.syncAjaxRequest({
                    action: 'wp_spider_verify_token',
                    token: token,
                    feature: feature,
                    period: period,
                    client_hash: clientHash,
                    nonce: wpSpiderMonitor.nonce
                });
                
                return response && response.success && response.data.valid === true;
                
            } catch (error) {
                console.error('[SpiderMonitor] Token verification error:', error);
                return false;
            }
        },
        
        /**
         * 检查令牌是否有效
         * @param {Object} tokenData 令牌数据
         * @returns {boolean} 令牌是否有效
         */
        isTokenValid: function(tokenData) {
            if (!tokenData || !tokenData.timestamp) {
                return false;
            }
            
            const now = Date.now();
            const tokenAge = now - tokenData.timestamp;
            
            return tokenAge < this.config.tokenExpiry;
        },
        
        /**
         * 生成客户端哈希
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @param {string} token 访问令牌
         * @returns {string} 客户端哈希
         */
        generateClientHash: function(feature, period, token) {
            const data = {
                feature: feature,
                period: period,
                token: token,
                timestamp: Date.now(),
                user_agent: navigator.userAgent,
                screen_resolution: screen.width + 'x' + screen.height,
                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
            };
            
            return this.simpleHash(JSON.stringify(data));
        },
        
        /**
         * 简单哈希函数
         * @param {string} str 输入字符串
         * @returns {string} 哈希值
         */
        simpleHash: function(str) {
            let hash = 0;
            if (str.length === 0) return hash.toString();
            
            for (let i = 0; i < str.length; i++) {
                const char = str.charCodeAt(i);
                hash = ((hash << 5) - hash) + char;
                hash = hash & hash; // 转换为32位整数
            }
            
            return Math.abs(hash).toString(16);
        },
        
        /**
         * 同步AJAX请求
         * @param {Object} data 请求数据
         * @returns {Object|null} 响应数据
         */
        syncAjaxRequest: function(data) {
            let result = null;
            let completed = false;
            
            $.ajax({
                url: wpSpiderMonitor.ajax_url,
                type: 'POST',
                data: data,
                async: false,
                timeout: 10000,
                success: function(response) {
                    result = response;
                    completed = true;
                },
                error: function(xhr, status, error) {
                    console.error('[SpiderMonitor] AJAX error:', error);
                    completed = true;
                }
            });
            
            return completed ? result : null;
        },
        
        /**
         * 显示付费提示
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         */
        showPremiumNotice: function(feature, period) {
            const message = this.getPremiumMessage(feature, period);
            this.displayNotification(message, 'error');
        },
        
        /**
         * 获取付费提示信息
         * @param {string} feature 功能名称
         * @param {string} period 时间范围
         * @returns {string} 提示信息
         */
        getPremiumMessage: function(feature, period) {
            const featureNames = {
                'trend_chart': '趋势图表',
                'top_spiders': 'Top蜘蛛统计',
                'access_paths': '访问路径分析',
                'article_crawl': '文章爬取分析',
                'ip_segments': 'IP段分析',
                'path_stats': '路径统计',
                'article_stats': '文章统计'
            };
            
            const featureName = featureNames[feature] || feature;
            
            if (period === 'week') {
                return `7天${featureName}需要激活PRO版本`;
            } else if (period === 'month') {
                return `30天${featureName}需要激活PRO版本`;
            } else {
                return `${featureName}需要激活PRO版本`;
            }
        },
        
        /**
         * 重置为免费选项
         * @param {jQuery} $selector 选择器元素
         */
        resetToFreeOption: function($selector) {
            const $freeOption = $selector.find('option').not('.premium-option').first();
            if ($freeOption.length) {
                $selector.val($freeOption.val());
            }
        },
        
        /**
         * 显示通知
         * @param {string} message 消息内容
         * @param {string} type 消息类型
         */
        displayNotification: function(message, type) {
            // 使用现有的通知系统
            if (typeof showNotification === 'function') {
                showNotification(message, type);
            } else {
                // 备用通知方法
                alert(message);
            }
        },
        
        /**
         * 清除缓存
         */
        clearCache: function() {
            this.cache.tokens = {};
            this.cache.permissions = {};
        },
        
        /**
         * 初始化安全模块
         */
        init: function() {
            // 定期清理过期缓存
            setInterval(() => {
                this.cleanExpiredCache();
            }, 60000); // 每分钟清理一次
            
            // 页面卸载时清理缓存
            $(window).on('beforeunload', () => {
                this.clearCache();
            });
        },
        
        /**
         * 清理过期缓存
         */
        cleanExpiredCache: function() {
            const now = Date.now();
            
            // 清理过期令牌
            Object.keys(this.cache.tokens).forEach(key => {
                const tokenData = this.cache.tokens[key];
                if (!this.isTokenValid(tokenData)) {
                    delete this.cache.tokens[key];
                }
            });
            
            // 清理过期权限缓存
            Object.keys(this.cache.permissions).forEach(key => {
                const permissionData = this.cache.permissions[key];
                if (now - permissionData.timestamp > 300000) { // 5分钟过期
                    delete this.cache.permissions[key];
                }
            });
        }
    };
    
    // 初始化安全模块
    $(document).ready(function() {
        window.WP_Spider_Premium_Security.init();
    });
    
})(jQuery);
